
chain-queue:     file format elf32-littlearm


Disassembly of section .init:

000103a8 <_init>:
   103a8:	e1a0c00d 	mov	ip, sp
   103ac:	e92ddff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, ip, lr, pc}
   103b0:	e24cb004 	sub	fp, ip, #4
   103b4:	e91baff0 	ldmdb	fp, {r4, r5, r6, r7, r8, r9, sl, fp, sp, pc}

Disassembly of section .plt:

000103b8 <printf@plt-0x14>:
   103b8:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)
   103bc:	e59fe004 	ldr	lr, [pc, #4]	; 103c8 <_init+0x20>
   103c0:	e08fe00e 	add	lr, pc, lr
   103c4:	e5bef008 	ldr	pc, [lr, #8]!
   103c8:	000107f0 	.word	0x000107f0

000103cc <printf@plt>:
   103cc:	e28fc600 	add	ip, pc, #0, 12
   103d0:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   103d4:	e5bcf7f0 	ldr	pc, [ip, #2032]!	; 0x7f0

000103d8 <puts@plt>:
   103d8:	e28fc600 	add	ip, pc, #0, 12
   103dc:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   103e0:	e5bcf7e8 	ldr	pc, [ip, #2024]!	; 0x7e8

000103e4 <malloc@plt>:
   103e4:	e28fc600 	add	ip, pc, #0, 12
   103e8:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   103ec:	e5bcf7e0 	ldr	pc, [ip, #2016]!	; 0x7e0

000103f0 <abort@plt>:
   103f0:	e28fc600 	add	ip, pc, #0, 12
   103f4:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   103f8:	e5bcf7d8 	ldr	pc, [ip, #2008]!	; 0x7d8

000103fc <__deregister_frame_info@plt>:
   103fc:	e28fc600 	add	ip, pc, #0, 12
   10400:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10404:	e5bcf7d0 	ldr	pc, [ip, #2000]!	; 0x7d0

00010408 <__uClibc_main@plt>:
   10408:	e28fc600 	add	ip, pc, #0, 12
   1040c:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10410:	e5bcf7c8 	ldr	pc, [ip, #1992]!	; 0x7c8

00010414 <exit@plt>:
   10414:	e28fc600 	add	ip, pc, #0, 12
   10418:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   1041c:	e5bcf7c0 	ldr	pc, [ip, #1984]!	; 0x7c0

00010420 <__register_frame_info@plt>:
   10420:	e28fc600 	add	ip, pc, #0, 12
   10424:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10428:	e5bcf7b8 	ldr	pc, [ip, #1976]!	; 0x7b8

0001042c <free@plt>:
   1042c:	e28fc600 	add	ip, pc, #0, 12
   10430:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10434:	e5bcf7b0 	ldr	pc, [ip, #1968]!	; 0x7b0

Disassembly of section .text:

00010438 <_start>:
   10438:	e3a0b000 	.word	0xe3a0b000
   1043c:	e3a0e000 	.word	0xe3a0e000
   10440:	e49d1004 	.word	0xe49d1004
   10444:	e1a0200d 	.word	0xe1a0200d
   10448:	e52d2004 	.word	0xe52d2004
   1044c:	e52d0004 	.word	0xe52d0004
   10450:	e59fc010 	.word	0xe59fc010
   10454:	e52dc004 	.word	0xe52dc004
   10458:	e59f000c 	.word	0xe59f000c
   1045c:	e59f300c 	.word	0xe59f300c
   10460:	eaffffe8 	.word	0xeaffffe8
   10464:	ebffffe1 	.word	0xebffffe1
   10468:	00010a78 	.word	0x00010a78
   1046c:	00010938 	.word	0x00010938
   10470:	000103a8 	.word	0x000103a8

00010474 <deregister_tm_clones>:
   10474:	e59f301c 	ldr	r3, [pc, #28]	; 10498 <deregister_tm_clones+0x24>
   10478:	e59f001c 	ldr	r0, [pc, #28]	; 1049c <deregister_tm_clones+0x28>
   1047c:	e0603003 	rsb	r3, r0, r3
   10480:	e3530006 	cmp	r3, #6
   10484:	912fff1e 	bxls	lr
   10488:	e59f3010 	ldr	r3, [pc, #16]	; 104a0 <deregister_tm_clones+0x2c>
   1048c:	e3530000 	cmp	r3, #0
   10490:	012fff1e 	bxeq	lr
   10494:	e12fff13 	bx	r3
   10498:	00020bf3 	.word	0x00020bf3
   1049c:	00020bf0 	.word	0x00020bf0
   104a0:	00000000 	.word	0x00000000

000104a4 <register_tm_clones>:
   104a4:	e59f1024 	ldr	r1, [pc, #36]	; 104d0 <register_tm_clones+0x2c>
   104a8:	e59f0024 	ldr	r0, [pc, #36]	; 104d4 <register_tm_clones+0x30>
   104ac:	e0601001 	rsb	r1, r0, r1
   104b0:	e1a01141 	asr	r1, r1, #2
   104b4:	e0811fa1 	add	r1, r1, r1, lsr #31
   104b8:	e1b010c1 	asrs	r1, r1, #1
   104bc:	012fff1e 	bxeq	lr
   104c0:	e59f3010 	ldr	r3, [pc, #16]	; 104d8 <register_tm_clones+0x34>
   104c4:	e3530000 	cmp	r3, #0
   104c8:	012fff1e 	bxeq	lr
   104cc:	e12fff13 	bx	r3
   104d0:	00020bf0 	.word	0x00020bf0
   104d4:	00020bf0 	.word	0x00020bf0
   104d8:	00000000 	.word	0x00000000

000104dc <__do_global_dtors_aux>:
   104dc:	e92d4010 	push	{r4, lr}
   104e0:	e59f402c 	ldr	r4, [pc, #44]	; 10514 <__do_global_dtors_aux+0x38>
   104e4:	e5d43000 	ldrb	r3, [r4]
   104e8:	e3530000 	cmp	r3, #0
   104ec:	18bd8010 	popne	{r4, pc}
   104f0:	ebffffdf 	bl	10474 <deregister_tm_clones>
   104f4:	e59f301c 	ldr	r3, [pc, #28]	; 10518 <__do_global_dtors_aux+0x3c>
   104f8:	e3530000 	cmp	r3, #0
   104fc:	0a000001 	beq	10508 <__do_global_dtors_aux+0x2c>
   10500:	e59f0014 	ldr	r0, [pc, #20]	; 1051c <__do_global_dtors_aux+0x40>
   10504:	ebffffbc 	bl	103fc <__deregister_frame_info@plt>
   10508:	e3a03001 	mov	r3, #1
   1050c:	e5c43000 	strb	r3, [r4]
   10510:	e8bd8010 	pop	{r4, pc}
   10514:	00020bf0 	.word	0x00020bf0
   10518:	00000000 	.word	0x00000000
   1051c:	00010af0 	.word	0x00010af0

00010520 <frame_dummy>:
   10520:	e59f3040 	ldr	r3, [pc, #64]	; 10568 <frame_dummy+0x48>
   10524:	e92d4010 	push	{r4, lr}
   10528:	e3530000 	cmp	r3, #0
   1052c:	0a000002 	beq	1053c <frame_dummy+0x1c>
   10530:	e59f1034 	ldr	r1, [pc, #52]	; 1056c <frame_dummy+0x4c>
   10534:	e59f0034 	ldr	r0, [pc, #52]	; 10570 <frame_dummy+0x50>
   10538:	ebffffb8 	bl	10420 <__register_frame_info@plt>
   1053c:	e59f0030 	ldr	r0, [pc, #48]	; 10574 <frame_dummy+0x54>
   10540:	e5903000 	ldr	r3, [r0]
   10544:	e3530000 	cmp	r3, #0
   10548:	1a000001 	bne	10554 <frame_dummy+0x34>
   1054c:	e8bd4010 	pop	{r4, lr}
   10550:	eaffffd3 	b	104a4 <register_tm_clones>
   10554:	e59f301c 	ldr	r3, [pc, #28]	; 10578 <frame_dummy+0x58>
   10558:	e3530000 	cmp	r3, #0
   1055c:	0afffffa 	beq	1054c <frame_dummy+0x2c>
   10560:	e12fff33 	blx	r3
   10564:	eafffff8 	b	1054c <frame_dummy+0x2c>
   10568:	00000000 	.word	0x00000000
   1056c:	00020bf4 	.word	0x00020bf4
   10570:	00010af0 	.word	0x00010af0
   10574:	00020afc 	.word	0x00020afc
   10578:	00000000 	.word	0x00000000

0001057c <init>:
  struct  node * front;
  struct  node * rear;
};

void init(struct queue * queue)
{
   1057c:	e52db004 	push	{fp}		; (str fp, [sp, #-4]!)
   10580:	e28db000 	add	fp, sp, #0
   10584:	e24dd00c 	sub	sp, sp, #12
   10588:	e50b0008 	str	r0, [fp, #-8]   ; r0 ---> fp-8
  queue->front = queue->rear = NULL;
   1058c:	e51b3008 	ldr	r3, [fp, #-8]   ; r3 <--- fp-8 = queue 
   10590:	e3a02000 	mov	r2, #0          ; r2 = 0
   10594:	e5832004 	str	r2, [r3, #4]    ; r2 = [r3+4] = queue->rear = 0
   10598:	e51b3008 	ldr	r3, [fp, #-8]   ; r3 <--- fp-8=queue
   1059c:	e5932004 	ldr	r2, [r3, #4]    ; r2 <--- r3 + 4 = 0
   105a0:	e51b3008 	ldr	r3, [fp, #-8]   ; r3 <--- fp-8=queue
   105a4:	e5832000 	str	r2, [r3]        ; r2 ---> [r3]=queue->front = 0
}
   105a8:	e24bd000 	sub	sp, fp, #0
   105ac:	e49db004 	pop	{fp}		; (ldr fp, [sp], #4)
   105b0:	e12fff1e 	bx	lr

000105b4 <enqueue>:

void enqueue(struct queue * queue, int value)
{
   105b4:	e92d4800 	push	{fp, lr}
   105b8:	e28db004 	add	fp, sp, #4
   105bc:	e24dd010 	sub	sp, sp, #16
   105c0:	e50b0010 	str	r0, [fp, #-16] ; r0 = queue = [fp-16]
   105c4:	e50b1014 	str	r1, [fp, #-20]	; 0xffffffec    r1 = value = [fp-20]
  struct node * des;

  des = (struct node *) malloc (sizeof(struct node));
   105c8:	e3a00008 	mov	r0, #8                  ; r0 = 8
   105cc:	ebffff84 	bl	103e4 <malloc@plt>
   105d0:	e1a03000 	mov	r3, r0              ; r3 <--- r0
   105d4:	e50b3008 	str	r3, [fp, #-8]       ; malloc return value
  if (!des) {
   105d8:	e51b3008 	ldr	r3, [fp, #-8] ; r3 <--- fp - 8
   105dc:	e3530000 	cmp	r3, #0
   105e0:	1a000003 	bne	105f4 <enqueue+0x40>
    printf("enqueue malloc fail.\n");
   105e4:	e59f0074 	ldr	r0, [pc, #116]	; 10660 <enqueue+0xac>
   105e8:	ebffff7a 	bl	103d8 <puts@plt>
    exit(-1);
   105ec:	e3e00000 	mvn	r0, #0
   105f0:	ebffff87 	bl	10414 <exit@plt>
  }

  des->data = value;
   105f4:	e51b3008 	ldr	r3, [fp, #-8]  ; malloc return value
   105f8:	e51b2014 	ldr	r2, [fp, #-20]	; 0xffffffec value
   105fc:	e5832000 	str	r2, [r3]        ; des->data = value
  des->next = NULL; // 队列只能从队尾插入所以下一个结点初始化为NULL
   10600:	e51b3008 	ldr	r3, [fp, #-8]   ; malloc return value
   10604:	e3a02000 	mov	r2, #0          ; r2 = 0
   10608:	e5832004 	str	r2, [r3, #4]    ;  des->next = 0

  if (queue->rear == NULL)
   1060c:	e51b3010 	ldr	r3, [fp, #-16] ; queue
   10610:	e5933004 	ldr	r3, [r3, #4]   ; queue->rear
   10614:	e3530000 	cmp	r3, #0
   10618:	1a000007 	bne	1063c <enqueue+0x88>
    queue->front = queue->rear = des;
   1061c:	e51b3010 	ldr	r3, [fp, #-16] ; queue
   10620:	e51b2008 	ldr	r2, [fp, #-8]  ; malloc return value
   10624:	e5832004 	str	r2, [r3, #4]   ; queue->rear = des
   10628:	e51b3010 	ldr	r3, [fp, #-16] ; queue
   1062c:	e5932004 	ldr	r2, [r3, #4]   ; r2 = queue->rear
   10630:	e51b3010 	ldr	r3, [fp, #-16] ; queue
   10634:	e5832000 	str	r2, [r3]       ; queue->front=queue->rear
   10638:	ea000006 	b	10658 <enqueue+0xa4>
  /*else // 可用这一句搞定。为添加注释，故改为两行
    queue->rear = queue->rear->next = des; */
  else {
    queue->rear->next = des;// 将队尾结点的指针指向新结点,如果新结点为第一个结点则q->rear->next相当于q->front->next 
   1063c:	e51b3010 	ldr	r3, [fp, #-16] ; queue
   10640:	e5933004 	ldr	r3, [r3, #4]   ; queue->rear
   10644:	e51b2008 	ldr	r2, [fp, #-8]  ; malloc return value
   10648:	e5832004 	str	r2, [r3, #4]   ; queue->rear->next=des
    queue->rear = des;// 将指向队尾的指针指向新结点 
   1064c:	e51b3010 	ldr	r3, [fp, #-16] ; queue
   10650:	e51b2008 	ldr	r2, [fp, #-8]  ; malloc return value
   10654:	e5832004 	str	r2, [r3, #4]   ; queue->rear = des
  }
}
   10658:	e24bd004 	sub	sp, fp, #4 
   1065c:	e8bd8800 	pop	{fp, pc}
   10660:	00010a88 	.word	0x00010a88

00010664 <dequeue>:

void dequeue(struct queue * queue)
{
   10664:	e92d4800 	push	{fp, lr}
   10668:	e28db004 	add	fp, sp, #4
   1066c:	e24dd010 	sub	sp, sp, #16
   1a0670:	e50b0010 	str	r0, [fp, #-16] ; fp-16 = queue
  struct node * des;
  int temp;

  if (queue->front == NULL) {
   10674:	e51b3010 	ldr	r3, [fp, #-16] ; queue
   10678:	e5933000 	ldr	r3, [r3]       ; queue->front
   1067c:	e3530000 	cmp	r3, #0         ; queue->front == 0 ?
   10680:	1a000003 	bne	10694 <dequeue+0x30>
    printf("queue is empty, diable dequeue.\n");
   10684:	e59f0054 	ldr	r0, [pc, #84]	; 106e0 <dequeue+0x7c>
   10688:	ebffff52 	bl	103d8 <puts@plt>
    exit(-1);
   1068c:	e3e00000 	mvn	r0, #0
   10690:	ebffff5f 	bl	10414 <exit@plt>
  }

  des = queue->front;
   10694:	e51b3010 	ldr	r3, [fp, #-16] ; queue
   10698:	e5933000 	ldr	r3, [r3]       ; queue->front
   1069c:	e50b3008 	str	r3, [fp, #-8]  ; des = queue->front
  //queue->front = des->next;
  queue->front = queue->front->next;
   106a0:	e51b3010 	ldr	r3, [fp, #-16] ; queue
   106a4:	e5933000 	ldr	r3, [r3]       ; r3 = queue->front
   106a8:	e5932004 	ldr	r2, [r3, #4]   ; r2 = queue->front->next
   106ac:	e51b3010 	ldr	r3, [fp, #-16] ; queue
   106b0:	e5832000 	str	r2, [r3]       ; queue->front=queue->front->next
  if (queue->front == NULL)
   106b4:	e51b3010 	ldr	r3, [fp, #-16] ; queue
   106b8:	e5933000 	ldr	r3, [r3]       ; queue->front
   106bc:	e3530000 	cmp	r3, #0
   106c0:	1a000002 	bne	106d0 <dequeue+0x6c>
    queue->rear = NULL;
   106c4:	e51b3010 	ldr	r3, [fp, #-16] ; queue
   106c8:	e3a02000 	mov	r2, #0
   106cc:	e5832004 	str	r2, [r3, #4] ; queue->rear
  free(des);
   106d0:	e51b0008 	ldr	r0, [fp, #-8] ; des
   106d4:	ebffff54 	bl	1042c <free@plt>
}
   106d8:	e24bd004 	sub	sp, fp, #4
   106dc:	e8bd8800 	pop	{fp, pc}
   106e0:	00010aa0 	.word	0x00010aa0

000106e4 <peekqueue>:

int peekqueue(struct queue * queue)
{
   106e4:	e92d4800 	push	{fp, lr}
   106e8:	e28db004 	add	fp, sp, #4
   106ec:	e24dd008 	sub	sp, sp, #8
   106f0:	e50b0008 	str	r0, [fp, #-8] ; queue
  if (queue->front == NULL) {
   106f4:	e51b3008 	ldr	r3, [fp, #-8] ; r3 = queue
   106f8:	e5933000 	ldr	r3, [r3]      ; r3 = queue->front
   106fc:	e3530000 	cmp	r3, #0
   10700:	1a000003 	bne	10714 <peekqueue+0x30>
    printf("queue is empty.\n");
   10704:	e59f0020 	ldr	r0, [pc, #32]	; 1072c <peekqueue+0x48>
   10708:	ebffff32 	bl	103d8 <puts@plt>
    return 0;
   1070c:	e3a03000 	mov	r3, #0
   10710:	ea000002 	b	10720 <peekqueue+0x3c>
  }

  return queue->front->data;
   10714:	e51b3008 	ldr	r3, [fp, #-8] ; queue
   10718:	e5933000 	ldr	r3, [r3]      ; queue->front
   1071c:	e5933000 	ldr	r3, [r3]      ; queue->data
}
   10720:	e1a00003 	mov	r0, r3 ; r0 = 0, or r0 = queue->front->data,return ;
   10724:	e24bd004 	sub	sp, fp, #4
   10728:	e8bd8800 	pop	{fp, pc}
   1072c:	00010ac0 	.word	0x00010ac0

00010730 <empty>:

int empty(struct queue * queue)
{
   10730:	e52db004 	push	{fp}		; (str fp, [sp, #-4]!)
   10734:	e28db000 	add	fp, sp, #0
   10738:	e24dd00c 	sub	sp, sp, #12
   1073c:	e50b0008 	str	r0, [fp, #-8] ; queue
  if (queue->front == NULL)
   10740:	e51b3008 	ldr	r3, [fp, #-8] ; queue
   10744:	e5933000 	ldr	r3, [r3]      ; queue->front
   10748:	e3530000 	cmp	r3, #0
   1074c:	1a000001 	bne	10758 <empty+0x28>
    return 1;
   10750:	e3a03001 	mov	r3, #1
   10754:	ea000000 	b	1075c <empty+0x2c>
  else
    return 0;
   10758:	e3a03000 	mov	r3, #0
}
   1075c:	e1a00003 	mov	r0, r3
   10760:	e24bd000 	sub	sp, fp, #0
   10764:	e49db004 	pop	{fp}		; (ldr fp, [sp], #4)
   10768:	e12fff1e 	bx	lr

0001076c <get>:

int get(struct queue * src)
{
   1076c:	e92d4800 	push	{fp, lr}
   10770:	e28db004 	add	fp, sp, #4
   10774:	e24dd008 	sub	sp, sp, #8
   10778:	e50b0008 	str	r0, [fp, #-8] ; src
  if (empty(src)) {
   1077c:	e51b0008 	ldr	r0, [fp, #-8] ; src
   10780:	ebffffea 	bl	10730 <empty>
   10784:	e1a03000 	mov	r3, r0  
   10788:	e3530000 	cmp	r3, #0
   1078c:	0a000003 	beq	107a0 <get+0x34>
    printf("queue is empty.\n");
   10790:	e59f0020 	ldr	r0, [pc, #32]	; 107b8 <get+0x4c>
   10794:	ebffff0f 	bl	103d8 <puts@plt>
    return 0;
   10798:	e3a03000 	mov	r3, #0
   1079c:	ea000002 	b	107ac <get+0x40>
  }
  
  return src->front->data;
   107a0:	e51b3008 	ldr	r3, [fp, #-8] ; src
   107a4:	e5933000 	ldr	r3, [r3]      ; src->front
   107a8:	e5933000 	ldr	r3, [r3]      ; src->fornt->data
}
   107ac:	e1a00003 	mov	r0, r3
   107b0:	e24bd004 	sub	sp, fp, #4
   107b4:	e8bd8800 	pop	{fp, pc}
   107b8:	00010ac0 	.word	0x00010ac0

000107bc <clear>:

void clear(struct queue * queue)
{
   107bc:	e92d4800 	push	{fp, lr}
   107c0:	e28db004 	add	fp, sp, #4
   107c4:	e24dd010 	sub	sp, sp, #16
   107c8:	e50b0010 	str	r0, [fp, #-16] ; queue
  struct node * des;

  des = queue->front;
   107cc:	e51b3010 	ldr	r3, [fp, #-16] ; queue
   107d0:	e5933000 	ldr	r3, [r3]       ; queue->front
   107d4:	e50b3008 	str	r3, [fp, #-8]  ; des=queue->front
  while (des != NULL) {
   107d8:	ea000009 	b	10804 <clear+0x48>
    queue->front = queue->front->next;
   107dc:	e51b3010 	ldr	r3, [fp, #-16] ; queue
   107e0:	e5933000 	ldr	r3, [r3]       ; queue->front
   107e4:	e5932004 	ldr	r2, [r3, #4]   ; queue->front->next
   107e8:	e51b3010 	ldr	r3, [fp, #-16] ; queue
   107ec:	e5832000 	str	r2, [r3]       ; queue->front=r2
    free(des);
   107f0:	e51b0008 	ldr	r0, [fp, #-8] ; des
   107f4:	ebffff0c 	bl	1042c <free@plt>
    des = queue->front;
   107f8:	e51b3010 	ldr	r3, [fp, #-16] ; queue
   107fc:	e5933000 	ldr	r3, [r3]       ; queue->front
   10800:	e50b3008 	str	r3, [fp, #-8] ; des=queue->front
void clear(struct queue * queue)
{
  struct node * des;

  des = queue->front;
  while (des != NULL) {
   10804:	e51b3008 	ldr	r3, [fp, #-8] ; des
   10808:	e3530000 	cmp	r3, #0
   1080c:	1afffff2 	bne	107dc <clear+0x20>
    queue->front = queue->front->next;
    free(des);
    des = queue->front;
  }

  queue->rear = NULL;
   10810:	e51b3010 	ldr	r3, [fp, #-16] ; queue
   10814:	e3a02000 	mov	r2, #0
   10818:	e5832004 	str	r2, [r3, #4] ; queue->rear
}
   1081c:	e24bd004 	sub	sp, fp, #4
   10820:	e8bd8800 	pop	{fp, pc}

00010824 <length>:

int length(struct queue * src)
{
   10824:	e52db004 	push	{fp}		; (str fp, [sp, #-4]!)
   10828:	e28db000 	add	fp, sp, #0
   1082c:	e24dd014 	sub	sp, sp, #20
   10830:	e50b0010 	str	r0, [fp, #-16] ; src
  struct node * des;
  int len;

  des = src->front;
   10834:	e51b3010 	ldr	r3, [fp, #-16] ; src
   10838:	e5933000 	ldr	r3, [r3]       ; src->front
   1083c:	e50b3008 	str	r3, [fp, #-8]  ; des
  len = 1;
   10840:	e3a03001 	mov	r3, #1 
   10844:	e50b300c 	str	r3, [fp, #-12] ; len
  while (des != src->rear) {
   10848:	ea000005 	b	10864 <length+0x40>
    len++;
   1084c:	e51b300c 	ldr	r3, [fp, #-12] ; len
   10850:	e2833001 	add	r3, r3, #1     ; len = len+1
   10854:	e50b300c 	str	r3, [fp, #-12] ; len
    des = des->next;
   10858:	e51b3008 	ldr	r3, [fp, #-8] ; des
   1085c:	e5933004 	ldr	r3, [r3, #4]  ; des->rear
   10860:	e50b3008 	str	r3, [fp, #-8] ; des=des->rear
  struct node * des;
  int len;

  des = src->front;
  len = 1;
  while (des != src->rear) {
   10864:	e51b3010 	ldr	r3, [fp, #-16] ; src
   10868:	e5932004 	ldr	r2, [r3, #4]   ; src->rear
   1086c:	e51b3008 	ldr	r3, [fp, #-8]  ; des
   10870:	e1520003 	cmp	r2, r3
   10874:	1afffff4 	bne	1084c <length+0x28>
    len++;
    des = des->next;
  }

  return len;
   10878:	e51b300c 	ldr	r3, [fp, #-12] ; len
}
   1087c:	e1a00003 	mov	r0, r3
   10880:	e24bd000 	sub	sp, fp, #0
   10884:	e49db004 	pop	{fp}		; (ldr fp, [sp], #4)
   10888:	e12fff1e 	bx	lr

0001088c <display>:

void display(struct queue * src)
{
   1088c:	e92d4800 	push	{fp, lr}
   10890:	e28db004 	add	fp, sp, #4
   10894:	e24dd010 	sub	sp, sp, #16
   10898:	e50b0010 	str	r0, [fp, #-16] ; src
  struct node * des;

  if (src->front == src->rear)
   1089c:	e51b3010 	ldr	r3, [fp, #-16] ; src
   108a0:	e5932000 	ldr	r2, [r3]       ; src->front
   108a4:	e51b3010 	ldr	r3, [fp, #-16] ; src
   108a8:	e5933004 	ldr	r3, [r3, #4]   ; src->rear
   108ac:	e1520003 	cmp	r2, r3
   108b0:	1a000000 	bne	108b8 <display+0x2c>
    return ;
   108b4:	ea00001b 	b	10928 <display+0x9c>

  des = src->front;
   108b8:	e51b3010 	ldr	r3, [fp, #-16] ; src
   108bc:	e5933000 	ldr	r3, [r3]       ; src->front
   108c0:	e50b3008 	str	r3, [fp, #-8]  ; des = src->front
  while (des != src->rear) {
   108c4:	ea000007 	b	108e8 <display+0x5c>
    printf(" %d ", des->data);
   108c8:	e51b3008 	ldr	r3, [fp, #-8] ; des
   108cc:	e5933000 	ldr	r3, [r3]      ; des->data
   108d0:	e1a01003 	mov	r1, r3
   108d4:	e59f0054 	ldr	r0, [pc, #84]	; 10930 <display+0xa4>
   108d8:	ebfffebb 	bl	103cc <printf@plt>
    des = des->next;
   108dc:	e51b3008 	ldr	r3, [fp, #-8] ; des
   108e0:	e5933004 	ldr	r3, [r3, #4]  ; des->next
   108e4:	e50b3008 	str	r3, [fp, #-8] ; des=des->next

  if (src->front == src->rear)
    return ;

  des = src->front;
  while (des != src->rear) {
   108e8:	e51b3010 	ldr	r3, [fp, #-16] ; src
   108ec:	e5932004 	ldr	r2, [r3, #4]   ; src->rear
   108f0:	e51b3008 	ldr	r3, [fp, #-8]  ; des
   108f4:	e1520003 	cmp	r2, r3
   108f8:	1afffff2 	bne	108c8 <display+0x3c>
    printf(" %d ", des->data);
    des = des->next;
  }
  printf(" %d ", des->data);
   108fc:	e51b3008 	ldr	r3, [fp, #-8] ; des
   10900:	e5933000 	ldr	r3, [r3]      ; des->data
   10904:	e1a01003 	mov	r1, r3
   10908:	e59f0020 	ldr	r0, [pc, #32]	; 10930 <display+0xa4>
   1090c:	ebfffeae 	bl	103cc <printf@plt>
  printf("\nqueue length = %d\n\n", length(src));
   10910:	e51b0010 	ldr	r0, [fp, #-16]      ; src
   10914:	ebffffc2 	bl	10824 <length>
   10918:	e1a03000 	mov	r3, r0
   1091c:	e1a01003 	mov	r1, r3
   10920:	e59f000c 	ldr	r0, [pc, #12]	; 10934 <display+0xa8>
   10924:	ebfffea8 	bl	103cc <printf@plt>
}
   10928:	e24bd004 	sub	sp, fp, #4
   1092c:	e8bd8800 	pop	{fp, pc}
   10930:	00010ad0 	.word	0x00010ad0
   10934:	00010ad8 	.word	0x00010ad8

00010938 <main>:

int main()
{
   10938:	e92d4800 	push	{fp, lr}
   1093c:	e28db004 	add	fp, sp, #4
   10940:	e24dd010 	sub	sp, sp, #16
  struct queue queue;
  int i;
  
  init(& queue);
   10944:	e24b3010 	sub	r3, fp, #16 ; queue
   10948:	e1a00003 	mov	r0, r3      ; r0 = queue
   1094c:	ebffff0a 	bl	1057c <init>
  for(i = 1; i <= 10; i++) 
   10950:	e3a03001 	mov	r3, #1      ; r3 = 1
   10954:	e50b3008 	str	r3, [fp, #-8] ; i
   10958:	ea000006 	b	10978 <main+0x40>
    enqueue(& queue, i);
   1095c:	e24b3010 	sub	r3, fp, #16 ; queue
   10960:	e51b1008 	ldr	r1, [fp, #-8] ; i
   10964:	e1a00003 	mov	r0, r3
   10968:	ebffff11 	bl	105b4 <enqueue>
{
  struct queue queue;
  int i;
  
  init(& queue);
  for(i = 1; i <= 10; i++) 
   1096c:	e51b3008 	ldr	r3, [fp, #-8] ; 
   10970:	e2833001 	add	r3, r3, #1
   10974:	e50b3008 	str	r3, [fp, #-8]
   10978:	e51b3008 	ldr	r3, [fp, #-8]
   1097c:	e353000a 	cmp	r3, #10
   10980:	dafffff5 	ble	1095c <main+0x24>
    enqueue(& queue, i);

  display(& queue);		// 1  2  3  4  5  6  7  8  9  10 
   10984:	e24b3010 	sub	r3, fp, #16
   10988:	e1a00003 	mov	r0, r3
   1098c:	ebffffbe 	bl	1088c <display>
  enqueue(& queue, 11);
   10990:	e24b3010 	sub	r3, fp, #16
   10994:	e3a0100b 	mov	r1, #11
   10998:	e1a00003 	mov	r0, r3
   1099c:	ebffff04 	bl	105b4 <enqueue>
  display(& queue);		// 1  2  3  4  5  6  7  8  9  10  11
   109a0:	e24b3010 	sub	r3, fp, #16
   109a4:	e1a00003 	mov	r0, r3
   109a8:	ebffffb7 	bl	1088c <display>
  
  dequeue(& queue);		// del 1
   109ac:	e24b3010 	sub	r3, fp, #16
   109b0:	e1a00003 	mov	r0, r3
   109b4:	ebffff2a 	bl	10664 <dequeue>
  dequeue(& queue);		// del 2
   109b8:	e24b3010 	sub	r3, fp, #16
   109bc:	e1a00003 	mov	r0, r3
   109c0:	ebffff27 	bl	10664 <dequeue>
  dequeue(& queue);		// del 3
   109c4:	e24b3010 	sub	r3, fp, #16
   109c8:	e1a00003 	mov	r0, r3
   109cc:	ebffff24 	bl	10664 <dequeue>
  dequeue(& queue);		// del 4
   109d0:	e24b3010 	sub	r3, fp, #16
   109d4:	e1a00003 	mov	r0, r3
   109d8:	ebffff21 	bl	10664 <dequeue>
  dequeue(& queue);		// del 5
   109dc:	e24b3010 	sub	r3, fp, #16
   109e0:	e1a00003 	mov	r0, r3
   109e4:	ebffff1e 	bl	10664 <dequeue>
  display(& queue);		//  6  7  8  9  10  11
   109e8:	e24b3010 	sub	r3, fp, #16
   109ec:	e1a00003 	mov	r0, r3
   109f0:	ebffffa5 	bl	1088c <display>

  enqueue(& queue, 55);
   109f4:	e24b3010 	sub	r3, fp, #16
   109f8:	e3a01037 	mov	r1, #55	; 0x37
   109fc:	e1a00003 	mov	r0, r3
   10a00:	ebfffeeb 	bl	105b4 <enqueue>
  enqueue(& queue, 66);
   10a04:	e24b3010 	sub	r3, fp, #16
   10a08:	e3a01042 	mov	r1, #66	; 0x42
   10a0c:	e1a00003 	mov	r0, r3
   10a10:	ebfffee7 	bl	105b4 <enqueue>
  enqueue(& queue, 75);
   10a14:	e24b3010 	sub	r3, fp, #16
   10a18:	e3a0104b 	mov	r1, #75	; 0x4b
   10a1c:	e1a00003 	mov	r0, r3
   10a20:	ebfffee3 	bl	105b4 <enqueue>
  enqueue(& queue, 76);
   10a24:	e24b3010 	sub	r3, fp, #16
   10a28:	e3a0104c 	mov	r1, #76	; 0x4c
   10a2c:	e1a00003 	mov	r0, r3
   10a30:	ebfffedf 	bl	105b4 <enqueue>
  enqueue(& queue, 85);
   10a34:	e24b3010 	sub	r3, fp, #16
   10a38:	e3a01055 	mov	r1, #85	; 0x55
   10a3c:	e1a00003 	mov	r0, r3
   10a40:	ebfffedb 	bl	105b4 <enqueue>
  enqueue(& queue, 86);
   10a44:	e24b3010 	sub	r3, fp, #16
   10a48:	e3a01056 	mov	r1, #86	; 0x56
   10a4c:	e1a00003 	mov	r0, r3
   10a50:	ebfffed7 	bl	105b4 <enqueue>
  display(& queue);		// 6  7  8  9  10  11  55  66  75  76  85  86
   10a54:	e24b3010 	sub	r3, fp, #16
   10a58:	e1a00003 	mov	r0, r3
   10a5c:	ebffff8a 	bl	1088c <display>
  /*
  while(queue.front != NULL) {
    printf(" %d ", get(&queue));
    dequeue(& queue);
    }*/
  clear(& queue);
   10a60:	e24b3010 	sub	r3, fp, #16
   10a64:	e1a00003 	mov	r0, r3
   10a68:	ebffff53 	bl	107bc <clear>
}
   10a6c:	e1a00003 	mov	r0, r3
   10a70:	e24bd004 	sub	sp, fp, #4
   10a74:	e8bd8800 	pop	{fp, pc}

Disassembly of section .fini:

00010a78 <_fini>:
   10a78:	e1a0c00d 	mov	ip, sp
   10a7c:	e92ddff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, ip, lr, pc}
   10a80:	e24cb004 	sub	fp, ip, #4
   10a84:	e91baff0 	ldmdb	fp, {r4, r5, r6, r7, r8, r9, sl, fp, sp, pc}
